home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 13 - 1997 (partial) / 13.02 Feb 97 / HappyFace, a CTB Game / CTB.c next >
Encoding:
Text File  |  1996-10-17  |  19.1 KB  |  780 lines  |  [TEXT/CWIE]
  1. /* CTB.c - Handles action specific to the Communications Toolbox 
  2.  
  3. This file can be included in a C project or compiled as a 
  4. library.  It allows the programmer to initiate connections
  5. through a Communications Toolbox connection.  In theory, 
  6. It works with any connection tool.  It was most rigorously
  7. tested with the Appletalk ADSP tool.
  8.  
  9. Assumptions: 
  10.     You are running a machine and OS that has/supports
  11.         Communications Toolbox.
  12.     You will not attempt to cram more into the CTB buffers
  13.         than they can hold.
  14.     You will not stress-test the Asynchronous calls, which
  15.         may not be ready for prime time.
  16. */
  17.  
  18. // Necessary includes (uncomment or precompile)
  19. #include "Connections.h"
  20. #include "FileTransfers.h"
  21. #include "CommResources.h"
  22. #include "CTB.h"
  23.  
  24. // Private literals
  25. #define kPrefsType                'PREF'    // signature resource is
  26. #define kAppSignature            'FACE'    // registered w/Apple
  27. #define kClassCM                'cbnd'    // replace with your own
  28. #define rConnClassID            1001
  29. #define rFirstToolConfigID        2001
  30.  
  31. // Global variables
  32. static ConnHandle                 gConn = nil;
  33. static Boolean                    gAsyncCalls, gCTBInited = false;
  34. static CMFlags                    gFlags;
  35. static CMStatFlags                gPrevStatus;
  36. static MenuHandle                gConnMenu;
  37. static ConnectionCompletionUPP    gCMCompletion;
  38. static FileTransferSendUPP        gCMWriteProc;
  39. static FileTransferReceiveUPP    gCMReadProc;
  40.  
  41. //**********************************************************
  42. //
  43. // pStrCopy - Copy the value of p1 to p2
  44. //
  45. //**********************************************************
  46. static void pStrCopy(unsigned char *p1, unsigned char *p2)
  47. {
  48.     register short len = *p2++ = *p1++;
  49.     while (--len >= 0)
  50.         *p2++=*p1++;
  51. }
  52.  
  53. //**********************************************************
  54. //
  55. // GetOpenFileDir - Gets VRef and ParentDirId for open file
  56. //
  57. //**********************************************************
  58. static OSErr GetOpenFileDir(short openFileRef, short *vRef, 
  59.     long *parDirID)
  60. {
  61.     FCBPBRec pb;
  62.     OSErr theErr;
  63.         
  64.     pb.ioCompletion = nil;
  65.     pb.ioFCBIndx = 0;
  66.     pb.ioVRefNum = 0;
  67.     pb.ioRefNum = openFileRef;
  68.     pb.ioNamePtr = nil;
  69.     
  70.     theErr = PBGetFCBInfo(&pb, false);
  71.     
  72.     *vRef = pb.ioFCBVRefNum;
  73.     *parDirID = pb.ioFCBParID;
  74.     
  75.     return theErr;
  76. }
  77.  
  78. //**********************************************************
  79. //
  80. // OpenPrefsFile - Opens prefs, creates if not found
  81. //
  82. //**********************************************************
  83. static OSErr OpenPrefsFile(short *myRefNum, Boolean createIt)
  84. {
  85.     Str255    myFileName;
  86.     long    myDirID;
  87.     short    myVRef, appResRef;
  88.     OSErr    theErr;
  89.     FSSpec    mySpec, appDirSpec;
  90.     Boolean    found;
  91.         
  92.     *myRefNum = -1;
  93.     found = false;
  94.     pStrCopy("\pHappyFace Prefs", myFileName);
  95.     appResRef = CurResFile();
  96.  
  97.     theErr = GetOpenFileDir(appResRef, &myVRef, &myDirID);
  98.     if (!theErr) {
  99.         theErr = FSMakeFSSpec(myVRef, myDirID, myFileName, 
  100.             &appDirSpec);
  101.         if (!theErr) {
  102.             found = true;
  103.             BlockMove(&appDirSpec, &mySpec, sizeof(FSSpec));
  104.         }
  105.     }
  106.         
  107.     if ( (theErr == fnfErr) && createIt ) {
  108.         BlockMove(&appDirSpec, &mySpec, sizeof(FSSpec));
  109.         FSpCreateResFile(&mySpec, kAppSignature, kPrefsType, 0);
  110.         theErr = ResError();
  111.     }
  112.     
  113.     if (!theErr) {
  114.         *myRefNum = FSpOpenResFile(&mySpec, fsRdWrPerm);
  115.         theErr = ResError();
  116.     }
  117.     
  118.     return theErr;
  119. }
  120.  
  121. //**********************************************************
  122. //
  123. // CMCompetion - Completion routine for the Connection Mgr
  124. //
  125. //**********************************************************
  126. static pascal void CMCompletion(ConnHandle hConn)
  127. {
  128.     // Should at least check to see if (**hConn).errCode 
  129.     // is non-zero.  Perhaps use hConn to put any error 
  130.     // code in UserData for the main program to flush out.
  131. }
  132.  
  133. //**********************************************************
  134. //
  135. // CMWriteProc - Sends the data out through the connection
  136. //
  137. //**********************************************************
  138. static pascal OSErr CMWriteProc(Ptr thePtr, long theSize, 
  139.     CMFlags flags)
  140. {
  141.     long            count, returnVal;
  142.     EventRecord        theEvent;
  143.     CMBufferSizes    sizes;
  144.     Ptr                p;
  145.     OSErr            theErr;
  146.     CMStatFlags        status;
  147.     
  148.     returnVal = 0;
  149.     
  150.     if (gConn) {
  151.         p = thePtr;
  152.         count = theSize;// Give other processes time while
  153.         do {        // waiting for previous write to finish
  154.             if (gAsyncCalls) do {
  155.                 if (theErr = CMStatus(gConn, sizes, &status))
  156.                     return theErr;
  157.                 if (status & (cmStatusDWPend + cmStatusOpening))
  158.                     WaitNextEvent(nullEvent, &theEvent, 1, nil);
  159.             } while (status & (cmStatusDWPend + cmStatusOpening));
  160.             if (theErr = CMWrite(gConn, p, &count, cmData,
  161.                     gAsyncCalls, gCMCompletion, -1, flags))
  162.                 return theErr;
  163.             if (gAsyncCalls) {
  164.                 do { // async calls provide false count
  165.                     if (theErr = CMStatus(gConn, sizes, &status))
  166.                         return theErr;
  167.                     if (status & (cmStatusDWPend + cmStatusOpening))
  168.                         WaitNextEvent(nullEvent, &theEvent, 1, nil);
  169.                 } while (status & cmStatusDWPend);
  170.                 count = (**gConn).asyncCount[cmDataOut];
  171.             }
  172.             p += count;    // continue where we left off
  173.             theSize = theSize - count;
  174.             count = theSize;
  175.         } while (count > 0);
  176.     }
  177.     return noErr;
  178. }
  179.  
  180. //**********************************************************
  181. //
  182. // ConnEvent - Give the Connection a crack at the event
  183. //
  184. //**********************************************************
  185. Boolean ConnEvent(EventRecord *theEvent)
  186. { 
  187.     WindowPtr    theWindow;
  188.         
  189.     switch(theEvent->what) {
  190.         case autoKey:
  191.         case keyDown:
  192.             theWindow = FrontWindow();
  193.             break;
  194.         case mouseDown:
  195.             FindWindow(theEvent->where, &theWindow);
  196.             break;
  197.         case updateEvt:
  198.         case activateEvt:
  199.             theWindow = (WindowPtr)theEvent->message;
  200.             break;
  201.         default:
  202.             theWindow = nil; // only pass through above events
  203.             break;
  204.     }
  205.  
  206.     if (!gConn || !theWindow)
  207.         return false;
  208.     else if (gConn != (ConnHandle)GetWRefCon(theWindow))
  209.         return false;
  210.     else {
  211.         CMEvent(gConn, theEvent);
  212.         return true;
  213.     }
  214. }
  215.  
  216. //**********************************************************
  217. //
  218. // ConnActivate - Passes activate event on to Connection
  219. //
  220. //**********************************************************
  221. void ConnActivate(WindowPtr theWindow, Boolean becomingActive)
  222. {
  223.     GrafPtr    oldPort;
  224.         
  225.     if (gConn && theWindow) {
  226.         GetPort(&oldPort);
  227.         SetPort(theWindow);
  228.         CMActivate(gConn, becomingActive);
  229.         SetPort(oldPort);
  230.     }
  231. }
  232.  
  233. //**********************************************************
  234. //
  235. // ConnResume - Passes resume event on to Connection
  236. //
  237. //**********************************************************
  238. void ConnResume(WindowPtr theWindow, Boolean resuming)
  239. {    
  240.     GrafPtr oldPort;
  241.     
  242.     if (gConn && theWindow) {
  243.         GetPort(&oldPort);
  244.         SetPort(theWindow);
  245.         CMResume(gConn, resuming);
  246.         SetPort(oldPort);
  247.     }
  248. }
  249.  
  250. //**********************************************************
  251. //
  252. // putc - Sends a character out through the connection
  253. //
  254. //**********************************************************
  255. OSErr putc(unsigned char *c)
  256. {
  257.     return CMWriteProc((Ptr)c, 1L, gFlags);
  258. }
  259.  
  260. //**********************************************************
  261. //
  262. // CMReadProc - Reads data in from the connection
  263. //
  264. //**********************************************************
  265. static pascal OSErr CMReadProc(Ptr thePtr, long *theSize, 
  266.     CMFlags *flags)
  267.     // reads *theSize chars into dataPtr
  268.     // synchronous, no matter what gAsyncCalls says;
  269.     // will have to try harder to get the contents of a block
  270. { 
  271.     if (gConn)
  272.         return CMRead(gConn, thePtr, theSize, cmData, false, 
  273.             nil, 0, flags);
  274.     else {
  275.         *theSize = 0;
  276.         return noErr;
  277.     }
  278. }
  279.  
  280. //**********************************************************
  281. //
  282. // getc - gets a character in from the connection
  283. //
  284. //**********************************************************
  285. OSErr getc(unsigned char *c)
  286. {
  287.     OSErr    theErr;
  288.     long    theLen;
  289.     CMFlags    flags;
  290.     
  291.     theLen = 1;
  292.     theErr = CMReadProc((Ptr)c, &theLen, &flags);
  293.     if (!theLen)
  294.         *c = NULL;
  295.     return theErr;
  296. }
  297.  
  298. //**********************************************************
  299. //
  300. // InitCTBStuff - Initializes comm toolbox
  301. //
  302. //**********************************************************
  303. static OSErr InitCTB(void)
  304. {
  305.     short             theErr;
  306.  
  307.     if (!gCTBInited) {
  308.         if (theErr = InitCTBUtilities())
  309.             return theErr;
  310.         if (theErr = InitCRM())
  311.             return theErr;
  312.         if (theErr = InitCM())
  313.             return theErr;
  314.         // PowerPC friendly Mixed-Mode stuff follows
  315.         gCMCompletion = (ConnectionCompletionUPP)
  316.             NewConnectionCompletionProc((ProcPtr)CMCompletion);
  317.         gCMWriteProc = (FileTransferSendUPP)
  318.             NewFileTransferSendProc((ProcPtr)CMWriteProc);
  319.         gCMReadProc = (FileTransferReceiveUPP)
  320.             NewFileTransferReceiveProc((ProcPtr)CMReadProc);
  321.         gCTBInited = true;
  322.     }
  323.     return noErr;
  324. }
  325.  
  326. //**********************************************************
  327. //
  328. // FindTool - Tries to get the choice tool if 
  329. //                available, else tries first available.
  330. //
  331. //**********************************************************
  332. static OSErr FindTool(short *procID, Str255 toolName)
  333. {
  334.     Handle            rHand;
  335.     StringHandle    sH;
  336.     OSErr            theErr;
  337.  
  338.     *procID = -1;
  339.     theErr = noErr;
  340.     
  341.     // Get name of tool last used, and its procID
  342.     rHand = GetResource(kAppSignature, rConnClassID);
  343.     if (rHand) {
  344.         sH = (StringHandle)rHand;
  345.         pStrCopy(*sH, toolName);
  346.         *procID = CMGetProcID(toolName);
  347.     }
  348.     if (*procID == -1 ) {
  349.         // may not actually have a resource file open, or the
  350.         // tool we want is no longer in the extensions folder so
  351.         // get the name and procID of the first tool we find
  352.         if (!(theErr = CRMGetIndToolName(kClassCM, 1, toolName)))
  353.             *procID = CMGetProcID(toolName);
  354.         if (*procID == -1)
  355.             theErr = ResError();
  356.         if (!theErr)
  357.             theErr = kToolNotAvailErr;
  358.     }
  359.     return theErr;
  360. }
  361.  
  362. //**********************************************************
  363. //
  364. // ReadPrefs - Read prefs for tool of specified class
  365. //
  366. //**********************************************************
  367. static OSErr ReadPrefs(short *procID, Handle *configH)
  368. {
  369.     short     resFileRef;
  370.     Str255    toolName;
  371.     Handle    resH;
  372.     OSErr    theErr;
  373.     
  374.     theErr = OpenPrefsFile(&resFileRef, kDontCreate);
  375.     // if we can't open prefs, we can still get a tool
  376.     theErr = FindTool(procID, toolName);
  377.     *configH = nil;
  378.     
  379.     if (resFileRef != -1) {
  380.         if (!theErr) {
  381.             // if the resource file was opened, get the 
  382.             // configuration string from a resource
  383.             resH = GetNamedResource(kAppSignature, toolName);
  384.             if (resH) {
  385.                 *configH = resH;
  386.                 HandToHand(configH);
  387.                 ReleaseResource(resH);
  388.             }  else
  389.                 theErr = ResError();
  390.         }
  391.         CloseResFile(resFileRef);
  392.     }
  393.     return theErr; // could be returning kToolNotAvailErr
  394. }
  395.  
  396. //**********************************************************
  397. //
  398. // WritePrefs - Create/Update connection tool prefs
  399. //
  400. //**********************************************************
  401. static OSErr WritePrefs(ConnHandle hConn)
  402. {
  403.     Ptr                specP;
  404.     Handle            specH, resH;
  405.     Str255            tName, tClassName;
  406.     OSErr            theErr;
  407.     short            resID, resFileRef;
  408.     Size            hSize;
  409.     StringHandle    sH;
  410.     
  411.     if (!hConn)
  412.         return kNoConnectionErr;
  413.     
  414.     // Get the current tool's name and its config string
  415.     CMGetToolName((**hConn).procID, tName);
  416.     specP = CMGetConfig(hConn);
  417.     if (!specP)
  418.         return kGetConfigErr;
  419.     
  420.     if (theErr = OpenPrefsFile(&resFileRef, kDoCreate))
  421.         return theErr;
  422.             
  423.     // Update/Create resource specifying tool name
  424.     resID = rConnClassID;
  425.     pStrCopy("\pConnection Tool Name", tClassName);
  426.     sH = NewString(tName);
  427.     if (sH) {
  428.         hSize = GetHandleSize((Handle)sH);
  429.         resH = Get1Resource(kAppSignature, resID);
  430.         theErr = ResError();
  431.         if ((!resH) && ((theErr == resNotFound) || 
  432.                 (theErr == noErr))) {
  433.             AddResource((Handle)sH, kAppSignature, 
  434.                 resID, tClassName);
  435.             if (!(theErr = ResError()))
  436.                 WriteResource((Handle)sH);
  437.             if (!theErr)
  438.                 theErr = ResError();
  439.             ReleaseResource((Handle)sH);
  440.         } else if (resH) {
  441.             SetHandleSize(resH, hSize);
  442.             if (!(theErr = MemError())) {
  443.                 BlockMove(*sH, *resH, hSize);
  444.                 ChangedResource(resH);
  445.                 if (!(theErr = ResError()))
  446.                     WriteResource(resH);
  447.                 if (!theErr)
  448.                     theErr = ResError();
  449.             }
  450.             ReleaseResource(resH);
  451.         }
  452.         DisposeHandle((Handle)sH);
  453.     } else
  454.         theErr = MemError();
  455.     
  456.     // Update/Create resource with the tool config string
  457.     if (!theErr) {
  458.         hSize = GetPtrSize(specP);
  459.         resH = Get1NamedResource(kAppSignature, tName);
  460.         theErr = ResError();
  461.         if ( (!resH) && ((theErr == resNotFound) || 
  462.                 (theErr == noErr)) ) {
  463.             theErr = noErr;
  464.             specH = NewHandle(hSize);
  465.             if (specH) {
  466.                 BlockMove(specP, *specH, hSize);
  467.                 do
  468.                     resID = UniqueID(kAppSignature);
  469.                 while (resID <= rFirstToolConfigID);
  470.                 AddResource(specH, kAppSignature, resID, tName);
  471.                 if (!(theErr = ResError()))
  472.                     WriteResource(specH);
  473.                 if (!theErr)
  474.                     theErr = ResError();
  475.                 ReleaseResource(specH);
  476.                 DisposeHandle(specH);
  477.             } else
  478.                 theErr = MemError();
  479.         } else if (resH) {
  480.             SetHandleSize(resH, hSize);
  481.             if (!(theErr = MemError())) {
  482.                 BlockMove(specP, *resH, hSize);
  483.                 ChangedResource(resH);
  484.                 if (!(theErr = ResError()))
  485.                     WriteResource(resH);
  486.                 if (!theErr)
  487.                     theErr = ResError();
  488.             }
  489.             ReleaseResource(resH);
  490.         }
  491.     }
  492.     
  493.     DisposePtr(specP);
  494.     CloseResFile(resFileRef);
  495.     
  496.     return theErr;
  497. }
  498.  
  499. //**********************************************************
  500. //
  501. // ChooseConn - Poses Connection Settings dialog
  502. //        allowing the user to choose and configure a tool
  503. //
  504. //**********************************************************
  505. OSErr ChooseConn(void)
  506. {
  507.     Point    where;
  508.     short    result;
  509.     OSErr    returnVal;
  510.     
  511.     returnVal = kNothingChosenErr;
  512.     
  513.     if (gConn) {
  514.         SetPt(&where, 20, 40);
  515.         HUnlock((Handle)gConn);
  516.         result = CMChoose(&gConn, where, nil);
  517.         HLock((Handle)gConn);
  518.         switch (result) {
  519.             case chooseOKMinor:
  520.             case chooseOKMajor:
  521.                 returnVal = noErr;
  522.                 break;
  523.             case chooseCancel:
  524.                 returnVal = kNothingChosenErr;
  525.                 break;
  526.             case chooseAborted:
  527.             case chooseDisaster:
  528.             case chooseFailed:
  529.             default:
  530.                 returnVal = result;
  531.                 break;
  532.         }
  533.     }
  534.     return returnVal;
  535. }
  536.  
  537. //**********************************************************
  538. //
  539. //    NewConn - Init connection mgr for use
  540. //
  541. //**********************************************************
  542. OSErr NewConn(Boolean async, Boolean initCTB, Boolean prompt)
  543. {
  544.     short            procID;
  545.     Handle            configH;
  546.     CMBufferSizes    sizes;
  547.     OSErr             theErr;
  548.     Boolean            newTool;
  549.     
  550.     if (gConn)
  551.         return kAlreadyInitErr;
  552.     
  553.     if (initCTB)
  554.         if (theErr = InitCTB())
  555.             return theErr;
  556.     
  557.     // Find user's preferred tool and config string
  558.     // or get defaults if blown or do not exist
  559.     theErr = ReadPrefs(&procID, &configH);
  560.     if (theErr == kToolNotAvailErr) {
  561.         newTool = true;
  562.         theErr = noErr;    // if problem is tool changed,
  563.     } else if (theErr)    // make note, else pitch
  564.         return theErr;
  565.     else
  566.         newTool = false;
  567.         
  568.     if (procID == -1)
  569.         return kNoConnToolErr;
  570.         
  571.     sizes[cmDataIn] = 0; // Asking for zero means leave 
  572.     sizes[cmDataOut] = 0; // buffer size up to tool
  573.     sizes[cmCntlIn] = 0;
  574.     sizes[cmCntlOut] = 0;
  575.     sizes[cmAttnIn] = 0;
  576.     sizes[cmAttnOut] = 0;
  577.     
  578.     // Get a new Connection Tool record
  579.     // and set config string as saved
  580.     gConn = CMNew(procID, cmData, sizes, 0, 0);
  581.     if (!gConn) {
  582.         if (configH)
  583.             DisposeHandle(configH);
  584.         return kCMNewErr;
  585.     } else if (configH) {
  586.         HLock(configH);     // don't let memory manager move  
  587.         CMSetConfig(gConn, *configH);    // dereferenced pointer
  588.         HUnlock(configH);
  589.         DisposeHandle(configH);
  590.     }
  591.     MoveHHi((Handle)gConn);
  592.     HLock((Handle)gConn);     // lock to access data at interrupt
  593.     
  594.     // pose Connection Settings dialog if desired or desired 
  595.     // tool or configuration string was not available
  596.     theErr = noErr;
  597.     if (prompt || newTool || !configH)
  598.         if (ChooseConn())
  599.             theErr = kNothingChosenErr;
  600.  
  601.     if (theErr) {
  602.         if (gConn)    // if ChooseDisaster, gConn already 
  603.             CMDispose(gConn);    // disposed & nil
  604.         gConn = nil;
  605.         return theErr;
  606.     }
  607.  
  608.     gFlags = false;
  609.     gAsyncCalls = async;
  610.     gPrevStatus = 0xFFFFFFFF;
  611.     gConnMenu = GetMenu(rConnMenuID);
  612.         
  613.     return noErr;
  614. }
  615.  
  616. //**********************************************************
  617. //
  618. //    OpenConn - Open connection with other copy
  619. //
  620. //**********************************************************
  621. OSErr OpenConn(void)
  622. {
  623.     if (!gConn)
  624.         return kNoConnectionErr;
  625.         
  626.     return CMOpen(gConn, gAsyncCalls, gCMCompletion, -1);
  627. }
  628.  
  629. //**********************************************************
  630. //
  631. //    ListenConn - Listen for connection with other copy
  632. //
  633. //**********************************************************
  634. OSErr ListenConn(void)
  635. {
  636.     CMBufferSizes    sizes;
  637.     CMStatFlags        status;
  638.     OSErr            theErr;
  639.         
  640.     if (gConn) {
  641.         theErr = CMStatus(gConn, sizes, &status);
  642.         if (!theErr) {    // async even if other calls are sync
  643.             if (!(status & cmStatusListenPend))
  644.                 theErr = CMListen(gConn, kAsync, gCMCompletion, -1);
  645.             else
  646.                 CMAbort(gConn); // close opened or listening
  647.         }
  648.     } else
  649.         theErr = kNoConnectionErr;
  650.         
  651.     return theErr;
  652. }
  653.  
  654. //**********************************************************
  655. //
  656. //    CloseConn - Close connection with other copy
  657. //
  658. //**********************************************************
  659. OSErr CloseConn(void)
  660. {
  661.     OSErr             theErr;
  662.     CMStatFlags        status;
  663.     CMBufferSizes    sizes;
  664.     
  665.     if (!gConn)                    // close only exists
  666.         return kNoConnectionErr;// and open or opening
  667.  
  668.     // close the connection, but only if it's open or trying to open
  669.     theErr = CMStatus(gConn, sizes, &status);
  670.     if (status & (cmStatusOpen + cmStatusOpening))
  671.         theErr = CMClose(gConn, gAsyncCalls, gCMCompletion, 
  672.             -1, false);
  673.  
  674.     return theErr;
  675. }
  676.  
  677. //**********************************************************
  678. //
  679. //    DisposeConn - Dispose CTB connection
  680. //
  681. //**********************************************************
  682. OSErr DisposeConn(void)
  683. {
  684.     if (!gConn)                // dispose only if exists
  685.         return kNoConnectionErr;
  686.  
  687.     // write resulting new preferences
  688.     WritePrefs(gConn); // may want to complain
  689.     
  690.     CloseConn();    // don't care about error, only 
  691.     HUnlock((Handle)gConn);    // calling in case open
  692.     CMDispose(gConn);
  693.     gConn = nil;
  694.     
  695.     return noErr;
  696. }
  697.  
  698. //**********************************************************
  699. //
  700. //    IdleConn - Performs event loop idle functions 
  701. //                also tells caller if online
  702. //
  703. //**********************************************************
  704. OSErr IdleConn(Boolean *online)
  705. {
  706.     CMStatFlags     status;
  707.     CMBufferSizes    sizes;
  708.     OSErr            theErr;
  709.     
  710.     theErr = noErr;
  711.     
  712.     if (gConn) {
  713.         CMIdle(gConn);    // Accept if we're not already busy
  714.         if (!(theErr = CMStatus(gConn, sizes, &status))) {
  715.             if (status & cmStatusIncomingCallPresent)
  716.                 CMAccept(gConn, true);
  717.             if (status != gPrevStatus) {
  718.                 *online = false;
  719.                 DisableItem(gConnMenu, rConnMItem);
  720.                 DisableItem(gConnMenu, rDiscMItem);
  721.                 DisableItem(gConnMenu, rListenMItem);
  722.                 DisableItem(gConnMenu, rSettingsMItem);
  723.                 if (status & cmStatusOpen) {
  724.                     EnableItem(gConnMenu, rDiscMItem);
  725.                     *online = true;
  726.                 } else if (status & cmStatusListenPend) {
  727.                     EnableItem(gConnMenu, rListenMItem);
  728.                     SetItem(gConnMenu, rListenMItem, 
  729.                         "\pStop Listening");
  730.                 } else {
  731.                     EnableItem(gConnMenu, rConnMItem);
  732.                     EnableItem(gConnMenu, rListenMItem);
  733.                     EnableItem(gConnMenu, rSettingsMItem);
  734.                     SetItem(gConnMenu, rListenMItem, "\pListen");
  735.                 }
  736.                 gPrevStatus = status;
  737.             }
  738.         }
  739.     } else {
  740.         DisableItem(gConnMenu, rConnMItem);
  741.         DisableItem(gConnMenu, rDiscMItem);
  742.         DisableItem(gConnMenu, rListenMItem);
  743.         DisableItem(gConnMenu, rSettingsMItem);
  744.     }
  745.     
  746.     return theErr;
  747. }
  748.  
  749. //**********************************************************
  750. //
  751. // DoConnMenu - Do action that corresponds to menu item
  752. //
  753. //**********************************************************
  754. void DoConnMenu(short itemNumber)
  755. {    
  756.     OSErr theErr;    // you will want to respond to errors
  757.     
  758.     switch(itemNumber) {
  759.         case rConnMItem:
  760.             if (OpenConn())
  761.                 SysBeep(1);
  762.             break;
  763.         case rDiscMItem:
  764.             if (CloseConn())
  765.                 SysBeep(1);
  766.             break;
  767.         case rListenMItem:
  768.             if (ListenConn())
  769.                 SysBeep(1);    // could be cmNotSupported
  770.             break;
  771.         case rSettingsMItem:
  772.             if (theErr = ChooseConn())
  773.                 if (theErr != kNothingChosenErr)
  774.                     SysBeep(1);
  775.             break;
  776.         default:
  777.             break;
  778.     }
  779. }
  780.